/*
 * FileManager.cpp
 *
 *  Created on: 15/05/2011
 *      Author: Fernando
 */
#include "FileManager.h"

FileManager* FileManager::fileManagerInstance = 0;

/**
 *
 * @return La unica instancia del FileManager. Si no existe, la crea y dsp la devuelve.
 */
FileManager * FileManager::getInstance() {
	if (!FileManager::fileManagerInstance) {
		FileManager::fileManagerInstance = new FileManager();
	}
	return FileManager::fileManagerInstance;
}
/**
 * Constructor
 **/
FileManager::FileManager() {
	this->archivoEntrenamiento = NULL;
	this->archivoReal = NULL;
	remove( "Archivos/resultados.txt" );
	archivoResultado = new LectorArchivos();
	archivoResultado->abrir("Archivos/resultados.txt");
	archivoStopwords = new LectorArchivos();
	archivoStopwords->abrir("Archivos/stopwords.txt");
}

/**
 * Destructor (ACLARACION: No es el malo de las tortugas ninjas.) cuack xD
 **/
FileManager::~FileManager() {
	/* delete archivoResultado;
	 * delete archivoStopwords;
	 */
}

/**
 * Se crea el archivo entrenamiento pasandole el path absoluto
 **/
void FileManager::asignarArchivoEntrenamiento(const std::string & path) {
	if (this->archivoEntrenamiento) {
		delete this->archivoEntrenamiento;
	}
	this->archivoEntrenamiento = new LectorArchivos;
	this->archivoEntrenamiento->abrir(path);
}

/**
 * Se crea el archivo Real pasandole el path absoluto
 **/
void FileManager::asignarArchivoReal(const std::string & path) {
	if (this->archivoReal) {
		delete this->archivoReal;
	}
	this->archivoReal = new LectorArchivos;
	this->archivoReal->abrir(path);
}

/**
 * A traves de getInfo se obtiene el autor (si es de entrenamiento) y la lista de palabras a traves de un objeto
 * @param tipoArchivo
 * @return Objeto info del archivo que se especifica por parametro.
 * Si no hay info autor = 0 y llega una lista vacia porque no me dejaba mandar null :(
 */
Info & FileManager::getInfo(Archivos tipoArchivo) {
	std::string linea;
	bool hayInfo = this->getArchivo(tipoArchivo).getLinea(linea);
	if (hayInfo) {
		//Lista<std::string> *lista = new Lista<std::string>(parsearPalabrasEnLista(linea));
		this->info.cargarInfo(parsearAutor(linea),
				parsearPalabrasEnLista(linea));
	} else
		this->info.clear();
	return info;

}

/***
 * @param tipoArchivo
 * @return Devuelve el archivo pedido a traves de los enums
 */
LectorArchivos & FileManager::getArchivo(Archivos tipoArchivo) {
	switch (tipoArchivo) {
	case ENTRENAMIENTO:
		return *(this->archivoEntrenamiento);
	case REAL:
		return *(this->archivoReal);
		case RESULTADO:
			return *(this->archivoResultado);
		case STOPWORDS:
			return *(this->archivoStopwords);
	}

}
/**
 * @param texto
 * @return El autor si es que tiene, si no devuelve NULL
 */
string FileManager::parsearAutor(std::string const & texto) {
	size_t divPosicion = buscarDivision(texto);
	if (divPosicion != std::string::npos) {
		return texto.substr(0, int(divPosicion));
	}
	return NULL;
}

size_t FileManager::buscarDivision(std::string const & texto) {
	return texto.find(SEPARADOR);
}

/**
 * @param texto
 * @return Una lista con las palabras ya modificadas
 */
Lista<std::string> & FileManager::parsearPalabrasEnLista(
		std::string & textoOriginal) {
	std::string texto = textoOriginal;
	std::string tempText;
	size_t divPosicion = buscarDivision(texto);
	size_t espacioPos;
	int continuar = true;
	Lista<std::string> *lista = new Lista<std::string> ();
	if (divPosicion != std::string::npos)
		texto = texto.substr(int(divPosicion) + 1);
	while (continuar) {
		espacioPos = texto.find_first_of(' ');
		if (espacioPos != std::string::npos) {
			tempText = texto.substr(0, int(espacioPos));
			limpiar(tempText);
			lista->add(tempText);
			texto = texto.substr(int(espacioPos) + 1);
		} else {
			lista->add(texto);
			continuar = false;
		}

	}
	return *lista;
}

/**
 * Contiene metodos para limpiar la palabra.
 * Por ahora: Cambiar de mayuscula a minuscula
 * @param palabra
 */
void FileManager::limpiar(std::string & palabra) {
	mayusAMinus(palabra);
	//replaceEnie(palabra);
}

void FileManager::mayusAMinus(std::string & palabra) {
	int i = 0;
	while (palabra[i] != 0) {
		if (palabra[i] >= 'A' && palabra[i] <= 'Z') {
			palabra[i] += 32;
		}
		i++;
	}
}

void FileManager::escribirLinea(Archivos tipoArchivo, string & linea) {
	getArchivo(tipoArchivo).escribirLinea(linea);
}
